package sanrenxing.Class.servlet;

import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.sun.deploy.panel.ITreeNode;
import org.omg.CORBA.INTERNAL;
import sanrenxing.Class.dao.ClasssDao;
import sanrenxing.Class.dao.impl.ClasssDaoImpl;
import sanrenxing.Class.domain.ClassName;
import sanrenxing.Class.domain.Classs;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@WebServlet("/ClassServlet")
public class ClassServlet extends HttpServlet {
    //定义数据层对象
    private ClasssDao classsDao=new ClasssDaoImpl();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");

        //获得请求路径中的操作方式参数
        String method=req.getParameter("method");
        //判断操作方式，执行方法代码
        if("findAll".equals(method)){
            //调用查询所有数据的方法
            findAll(req,resp);
        }else if("add".equals(method)){
            //调用增加班级的方法
            add(req,resp);
        }else if("update".equals(method)){
            //调用修改方法
            update(req,resp);
        }else if("batchDel".equals(method)){
            //调用删除方法
            batchDel(req,resp);
        }else if("delete".equals(method)){
            //删除单行
            delete(req,resp);
        }else if ("findClass".equals(method)){
            findClass(req,resp);
        }
    }

    private void findClass(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        //定义输出流对象
        PrintWriter out=resp.getWriter();
        //调用方法创建集合获取班级名称
        List<ClassName> classNameList=classsDao.findClassName();
        //定义Map集合
        Map<String,Object> map=new HashMap<>();
        //将集合放置进map
        map.put("json1",classNameList);
        //创建Gson
        Gson gson=new Gson();
        //通过gson将map序列化
       String json1=gson.toJson(map);


        if (json1!=""){
            out.print(json1);
        }else{
            out.print("no");
        }
    }

    /**
     * 删除数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void delete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //定义输出流对象
        PrintWriter out=resp.getWriter();
        //得到来自请求中的班级编号字符串
        String classIdStr=req.getParameter("classId");
        try{
            //把字符串转换为整型的班级编号
            int classIds=Integer.parseInt(classIdStr);
            //调用数据层代码进行删除
            classsDao.delete(classIds);
            //向客户端发送操作结果
            out.print("ok");
        }catch(Exception e){
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    /**
     * 批量删除数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void batchDel(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //定义输出流对象
        PrintWriter out=resp.getWriter();

        //得到来自请求中的班级编号字符串
        String classIdStr=req.getParameter("classIdStr");
        //对班级编号字符串按","进行分割
        String[] classIds=classIdStr.split(",");
        //由于是批量删除，使用异常和循环来进行判断删除是否成功
        try{
            //循环删除
            for(String classsStr:classIds){
                //把字符串转换为整型的班级编号
                int classId=Integer.parseInt(classsStr);
                //调用数据层代码进行删除
                classsDao.delete(classId);
            }
            //向客户端发送操作结果
            out.print("ok");
        }catch(Exception e){
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    /**
     * 修改emp表中的班级数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
        //定义输出对象
        PrintWriter out=resp.getWriter();
        //接收来自前端请求的json数据字符串
        String json=req.getParameter("json");
        //定义Gson操作对象
        Gson gson = new Gson();
        //通过gson对象将json数据转换成班级对象
        Classs classs= null;
        try {
            classs = gson.fromJson(json, Classs.class);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        //调用数据层方法，实现数据添加
        int rows=classsDao.update(classs);
        //判断操作是否成功
        if(rows>0){
            out.print("ok");
        }else{
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    private void add(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
        //定义输出对象
        PrintWriter out=resp.getWriter();
        //接收来自前端请求的json数据字符串
        String json=req.getParameter("json");
        //将req发送的学生人数转换为int类
        int studentCount= Integer.parseInt(req.getParameter("studentCount"));
        //获得班级名称
        String className=req.getParameter("className");
        //将req发送的教员Id转换为int类
        int instructorId= Integer.parseInt(req.getParameter("instructorId"));
        //将教师Id转换为int类
        int teacherId= Integer.parseInt(req.getParameter("teacherId"));
        //将班级id转换为int类
        int classId= Integer.parseInt(req.getParameter("classId"));
       //将获得的数据放到classs类中
        Classs classs=new Classs(classId,className,instructorId,teacherId,studentCount);
//        //定义Gson操作对象
//        Gson gson = new Gson();
//        //通过gson对象将json数据转换成班级对象
//        Classs classs= null;
//        try {
//            classs = gson.fromJson(json, Classs.class);
//        } catch (JsonSyntaxException e) {
//            e.printStackTrace();
//        }
        //调用数据层方法，实现数据添加
        int rows=classsDao.add(classs);
        //判断操作是否成功
        if(rows>0){
            out.print("ok");
        }else{
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    /**
     *
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    private void findAll(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
        //创建输出流对象
        PrintWriter out=resp.getWriter();
        //获取当前页数
        String pageStr = req.getParameter("page");
        //定义初始页面为1
        int page = 1;
        //如果获得的页面不为空并且长度大于0
        if(pageStr!=null && pageStr.trim().length()!=0){
            //转换为int类型
            page = Integer.parseInt(pageStr);
        }
        //获取每页行数
        String rowsStr = req.getParameter("limit");
        //定义初始行数为1
        int rows = 5;
        if(rowsStr!=null && rowsStr.trim().length()!=0){
            //转换为int类型
            rows = Integer.parseInt(rowsStr);
        }
        //定义用于构造多条件查询的班级对象
        Classs classs= new Classs();
        //获取来自请求中的empNo班级编号
        String classId=req.getParameter("classId");
        //判断班级编号，是否加入到班级对象中
        if(classId!=null && classId.trim().length()!=0){

            classs.setClassId(Integer.parseInt(classId));
        }
        //获取来自请求中的班级名称
        String className=req.getParameter("className");
        //判断并加入到班级对象中
        if(className!=null && className.trim().length()!=0){
            classs.setClassName(className);
        }
        //获取来自请求的部门编号
        String instructorId=req.getParameter("instructorId");
        //判断并加入
        if(instructorId!=null && instructorId.trim().length()!=0){
            classs.setInstructorId(Integer.parseInt(instructorId));
        }
        //调用数据方法，根据班级对象构造查询条件字符串
        String condition=classsDao.getCondition(classs);
        //执行多条件分页查询
        List<Classs> empList=classsDao.findByPage(rows,page,condition);
        //多条件查询表中总记录数
        int totalRows=classsDao.count(condition);

        //定义映射集合对象
        Map<String,Object> mapData=new HashMap<String,Object>();
        //在映射集合中添加key为code，值为0的状态码
        mapData.put("code",0);
        //在映射集合中添加key为msg,值为响应信息字符串
        mapData.put("msg","");
        //在映射集合中添加key为count,值总行数的数据对
        mapData.put("count",totalRows);
        //在映射集合中添加key为data,值为员集合对象
        mapData.put("data",empList);
        //建立Gson对象
        Gson gson=new Gson();
        //使用Gson对象把映射集合转换为json格式数据
        String json1=gson.toJson(mapData);
        //将json数据输出到客户端
        out.write(json1);
        //关闭输出流对象
        out.close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req, resp);
    }
}
